
Analizziamo ora gli algoritmi utilizzati per realizzare il progetto.

\begin{algorithm}
	 \SetAlgoLined
	 \KwIn{$\Gamma,\,C$}
	 \KwData{$S,\,E^*,\,e,\,O,\,I,\,E_P^\prime$}
	 \KwResult{$E_P$}
	 $(e,\,I) \leftarrow \;$Grounded($\Gamma,\,C$) \\	
	 $E_P \leftarrow \{e\}$ \\
	 \If {I.\upshape{isEmpty}}
		{\Return Ep}
	$\Gamma \leftarrow \Gamma \downarrow I$ \\			
	$S \leftarrow$ SCCSSEQ($\Gamma$) \\
	\ForEach{$S_i \in S$}{
		$E_P^\prime \leftarrow \phi $\\
		\ForEach {$e \in E_P$} {
			$(O,\,I) \leftarrow$ boundcond($\Gamma,\,S_i,\,e$) \\
			\If {O.\upshape{isempty}} {
				\If {I.\upshape{isempty}} {
					$E^* \leftarrow \phi$
					}
				\Else { 
					$E^* \leftarrow$ SATPref($\Gamma \downarrow S_i,\,I \cap C$)
					}
				}
			\Else { 
				$E^* \leftarrow$ Pref($\Gamma \downarrow (S_i{\backslash} O),\, I \cap C$)
				}
			$E_P^\prime \leftarrow E_P^\prime \cup (e \otimes E^*)$
			}
		$E_P \leftarrow E_P^\prime$
	}
	\Return $E_P$
	\caption{Algoritmo Pref.}
\end{algorithm}
	
\begin{algorithm}
	\SetAlgoLined
	\KwIn{$\Gamma,\,C$}
	\KwData{$N,\,ANC,\,ANI$}
	\KwResult{$e,\,I$}
	$e \leftarrow \emptyset$ \\
	$I \leftarrow \Gamma.A$ \\
	\tcc{N sono tutti e soli i nodi in C non attaccati da nodi in I} 
	\While {$N \neq \emptyset \;\;$} { 
		$e \leftarrow e \cup N$ \\
		$ANC \leftarrow $\upshape{sottoinsieme di C contenente tutti 
				i nodi attaccati dai nodi in N} \\
		$ANI \leftarrow $\upshape{sottoinsieme di I contenente tutti
				i nodi attaccati dai nodi in N} \\	
		$C \leftarrow C {\backslash} (N \cup ANC)$ \\
		$I \leftarrow I {\backslash} (N \cup ANI)$ \\
	}
	\Return $(e,\,I)$
	\caption{Algoritmo Grounded.}
\end{algorithm}

\begin{algorithm}
	\SetAlgoLined
	\KwIn{$\Gamma,\,S_i,\,e$}
	\KwResult{$O,\,I$}
	$O \leftarrow \{ n |\; n\in S_i,\;\;\; n \;$is attacked by $m \in e \} $ \\
	$temp \leftarrow\,\{ n |\; n \in\Gamma\setminus (S_i \cup e),\;\;\; n\;$ is attacked by $m \in e\}$ \\
	$I \leftarrow \{ n |\; n \in S_i\setminus O,$
		\begin{align*} % Would be fralign* instead.
		    (\nexists n \in I: n\; \textrm{is attacked by}\; m \in \Gamma\setminus S_i ) \;\; \oplus \\
		   	(\nexists n \in I: n\; \textrm{is attacked by}\; m \notin temp ) \\ 
		\end{align*}
	\Return $(O,\,I)$
	\caption{Algoritmo Boundcond.}
\end{algorithm}


\begin{algorithm}
	\SetAlgoLined
	\KwIn{$G\,=\,(V,\,E)$}
	\KwResult{insieme di componenti fortemente connesse}

  	index $\leftarrow$ 0\\
	Stack $\leftarrow$ $\emptyset$\\
  	\ForEach {$v \in V$} {
    		\If {v.index = undefined} {
     			strongconnect(v);
    		}
  	}
	\Return Stack

	\caption{Algoritmo di Tarjan}
\end{algorithm}

\begin{algorithm}
	\SetAlgoLined
	\KwIn{un singolo nodo}

	v.index $\leftarrow$ index \\
	v.lowlink $\leftarrow$ index \\
	index $\leftarrow$ index + 1 \\
	S.push(v) \\

	//prendo i successor di v \\
	\ForEach {($(v, w) \in E $)} {
		\If {w.index = undefined} {
			// il successore w non e' ancora stato visitato \\
			strongconnect(w) \\
			v.lowlink $\leftarrow$ min(v.lowlink, w.lowlink) \\
		} \Else {
			\If {$ w \in S $} {
				// il successore w si trova nello stack e quindi anche nel SCC corrente \\
				v.lowlink $\leftarrow$ min(v.lowlink, w.index) \\
			 }
		}
	}

	// se v si configura come un nodo radice, effettua un pop dallo stack e genera
	un nuovo SCC \\
	\If {(v.lowlink = v.index)} {
		newSCC $\leftarrow$ createSCC() \\
		\Repeat {(w = v)}{
			w $\leftarrow$ Stack.pop() \\
			newSCC.add(w) \\
		}
		SCClist.add(newSCC) \\
	}
	
	\caption{Funzione strongconnect utilizzata dall'algoritmo di Tarjan}
\end{algorithm}

\begin{algorithm}

	\SetAlgoLined
	\KwIn{SCCset}
	\KwResult{$\{V, E\}$}

	\ForEach {(nodei $\in$ SCCset)} {
		i\_attacks\_j $\leftarrow$ false \\
		\While {(nodej $\not =$ nodei $\wedge$ i\_attacks\_j = false)} {
			\If { nodei.getSubsetAttackedBy(nodej)$\leftarrow$ $\emptyset$ } {
				addEdge(\{nodej $\rightarrow$ nodei\},  E) \\ 
				i\_attacks\_j $\leftarrow$ true
			}
			nodej $\leftarrow$ nextNode(SCCset)
		}
	}
	\Return G=\{SCCset, E\}
	\caption{Algoritmo linkMacroGraph utilizzato per creare un grafo partendo dai
	singoli SCC}
\end{algorithm}


\begin{algorithm}
	
	\SetAlgoLined
	\KwIn{\{V,E\}}
	\KwResult{\{V, E\}}

	L $\leftarrow$ Empty list that will contain the sorted elements \\
	S $\leftarrow$ Set of all nodes with no incoming edges \\
	\While {(S $\not =$ $\emptyset$)} {
		n $\leftarrow$ pop(S) \\
		addToTail(n, L) \\
		\ForEach {node m with an edge e = (n, m) } {
			removeEdge(e, E)
			\If {(m has no other incoming edges)} {
				push(m, S)
			}
		}
    }
	\If {(E $\not =$ $\emptyset$)} {
		\Return error //il grafo ha almeno un ciclo
	} \Else {
		\Return L //una lista di nodi ordinati in modo topologico
	}
	
	\caption{Algoritmo di Kahn utilizzato per ordinare topologicamente i nodi}
\end{algorithm}
